import clsx from 'clsx';
import cloneDeep from 'lodash/cloneDeep'
import message from '../../framework/common/utils/message';
import eventBus from '../../framework/common/eventBus';
import { scrollTo } from "../../framework/common/utils";

/**
 * 审批步骤的公共方法
 */

/**
 * 清洗数据，只清洗步骤信息
 */
function initStepData ({
    steps,//步骤
    multiUserSelect,//tplstepData.ProcessInfo.MultiUserSelect
}){

    steps.forEach(function(step, stepIndex){
        if(step?.nodes){//步骤存在责任人
            step.nodes.forEach(function(node, ind){
                //1.步骤责任人给一个头像颜色
                node.__auditorColor__ = ['#1990FF','#F5A623','#01D4A9'][ind%3];
                if(step.stepAttrs.multi_type == 'Multi'){//多人
                    //2.串行 并行 多人&&可调整责任人，责任人给默认Checked=true
                    if(step.stepAttrs.adjust_multi_auditor){//可调整责任人
                        if(multiUserSelect){//有这个参数，把多人步骤的用户默认全选
                            node.Checked = true
                        }
                    }else{//多人，不可调整责任人，直接默认所有人全选
                        node.Checked = true;//给多人并行 和 多人串行  允许调整责任人的情况下，默认给node加上Checked = true的属性
                    }
                }else{//单人
                    if(step.nodes.length === 1){
                        node.Checked = true;//单人只解析到1个人，给这个人加上Checked=true
                    }
                }
            })
        }

        if(
            (
                !step.nodes 
                || step.nodes.length == 0 
                || step.is_user_reset_activity == 1
            )
            && step.stepAttrs 
            && step.stepAttrs.adjust_auditor 
            && (
                step.stepAttrs.no_auditor_rules 
                && step.stepAttrs.no_auditor_rules.indexOf('SkipStep') == -1 
                || step.stepAttrs.archived_mode == 'Auditor'
            ) 
            && step.needChoose == 1
        ){//步骤没解析到责任人，但是高级设置配置了可调整责任人
            step.__needChooseAuditor__ = true;//需要选择责任人
        }
    });


    return steps;
}

/** 
 * 清洗步骤数据，包括校验信息
*/
function initAllStepData({
    opinion="",//审批意见 只有发起、草稿才需要传
    stepData,
    multiUserSelect//是否需要默认选中多人步骤中的所有人
}){
    let actual_steps = cloneDeep(stepData.actuals);//原始步骤，不包括branch步骤

    //数据清洗
    actual_steps = initStepData({
        steps: actual_steps,
        multiUserSelect: multiUserSelect
    });//初始化审批步骤数据清洗

    let approveSteps = cloneDeep(actual_steps);//包含分支切换的步骤
    if (stepData.branch && stepData.branch.length) {
        approveSteps.push({ branch: stepData.branch });
    }
    var validateResult = null;
    if (stepData.validateResult) {

        // 有新发布的表单
        if (stepData.validateResult.errorCode == 10005) {//只有发起、草稿才会进
            message.info({
                content: "流程已发布新表单，将重置当前页面。<br />重置后，若表单中有可编辑信息请重新填写。",
                afterClose:function(){
                    window.localStorage.setItem('opinion', opinion);
                    window.location.href = window.location.href + '&is_reload=1';//is_reload在別的地方可能会 有用
                }
            });
            return false;
        }

        if (stepData.validateResult.errorCode == 30015) {//30014 是需要确认分支
            validateResult = stepData.validateResult;
        }
        if (stepData.validateResult.errorCode == 30012 || stepData.validateResult.errorCode == 30011) {
            validateResult = "";
        }
    }
    return{
        approveSteps: approveSteps,//包括branch步骤，branch是选择分支步骤的信息
        actual_steps: actual_steps,//不包括branch步骤
        validateResult: validateResult//获取步骤导致的错误信息
    }
}

//校验当前步骤是否存在责任人
function __checkNodes({
    step//当前步骤
}){
    let returnResult = {
        isSuccess: 1,
        message: ""
    }
    if(step.nodes.length == 0){//沒解析到责任人
        if(step?.stepAttrs?.no_auditor_rules.indexOf('SkipStep') > -1){//高级模式开启了“无责任人跳过”
            return returnResult;//校验通过，直接返回默认成功结果
        }
    }

    let checkNodes = step.nodes.filter(function(node){
        if(node.Checked == true){
            return node;
        }
    })//找到 Checked = true 的用户   

    if(checkNodes.length < 1){//如果已选用户数量 < 1 ，就是没人
        returnResult.isSuccess = 0;
        if(step.nodes.length > 0){//解析到了责任人，但是未选人
            returnResult.message = "“" + step.name + "”步骤未选人，请选择！";
        }else{//没解析到责任人
            if(step?.stepAttrs?.adjust_auditor === true){//步骤无人时，可调整责任人
                returnResult.message = "“" + step.name + "”步骤未选人，请选择！";
            }else{//步骤不可调整责任人，tips 目前的逻辑是出现这种情况，按钮变为我知道了，无法触发前端校验
                returnResult.message = "“" + step.name + "”步骤无责任人，请联系管理员调整！";
            }
        }
    }
    return returnResult;
}
/**
 * 校验步骤node信息
 */
function validateSteps({
    steps,
    tplData
}){
    var res_obj = { 
        isSuccess: 1
    };

    //校验每个步骤是否有没有没有选择责任人
    steps.find(function(step, step_index) {

        if(step_index == 0){//不校验第一个步骤
            
        }else{
            let stepAttrs = step.stepAttrs;//步骤属性

            //1.校验最后一个步骤
            if(step_index === steps.length -1){

                //1.1 最后一个步骤是选分支
                if (step.branch !== undefined) {

                    //找到选中的分支
                    var branchChoosed = null;
                    step.branch.forEach(function(item, i) {
                        if (item.chooseed) {
                            branchChoosed = item;
                        }
                    });

                    if (branchChoosed) {//存在选中分支
                        //说明分支是最后的步骤，但是没解析到后续步骤
                        res_obj.isSuccess = 0;
                        res_obj.message = "“" + branchChoosed.name + "”分支定义有误，无法到达下一步骤！";
                        return true;
                    } else {//不存在选中分支
                        res_obj.isSuccess = 0;
                        res_obj.message = "请选择步骤！";
                        return true;
                    }
                }

                //1.2 最后一个步骤是归档步骤
                if(step.step_type == 2){
                    if(stepAttrs?.archived_mode == "Auditor"){//处理人归档（手动归档）
                        let checkNodesResult = __checkNodes({
                            step: step//当前步骤
                        })
                        res_obj.isSuccess = checkNodesResult.isSuccess;
                        res_obj.message = checkNodesResult.message;
                        if(res_obj.isSuccess == 0){//校验未通过
                            return true;
                        }
                    }
                }
            }

            //2.校验临时步骤
            if(step.temporaryStep){
                if(step.name == '' || step.nodes.length == 0){//临时步骤没步骤名称 或者 没选择责任人
                    res_obj.message = "临时步骤未设置步骤名称或者未选择责任人";
                    res_obj.isSuccess = 0;//需要校验
                    return true;
                }
            }else{
                //3.校验其他步骤
                if(
                    step.step_type != 8 // 分流|合流 步骤不校验是否有责任人
                    && step.step_type != 2 //归档步骤上面单独校验了
                    && step.branch === undefined//当前步骤不是最末步骤，存在选分支的情况不校验
                ){
                    let checkNodesResult = __checkNodes({
                        step: step//当前步骤
                    })
                    res_obj.isSuccess = checkNodesResult.isSuccess;
                    res_obj.message = checkNodesResult.message;
                    if(res_obj.isSuccess == 0){//校验未通过
                        return true;
                    }
                }
            }
        }

    });

    if (res_obj.isSuccess == 0) {
        res_obj.message && message.info({
            content: res_obj.message
        })

        //滚动到校验失败的步骤
        scrollTo({
            scrollItemClass: ".js-steps_wrap .errorStep",
            contentClass: ".js-steps_wrap"
        });

        return false;
    }
    
    return true;
}

//流程图联动定位流程路径的中转方法
if(!window.setSelectedStep){
    window.setSelectedStep = function (positioning){
        
        if(window._selectrdStepId && window._selectrdStepId.length){
            //1.流程图滚动定位到指定步骤
            eventBus.publish("scrollFlowPathView.update", {
                stepId: window._selectrdStepId[0]
            })
            
            //2.选中iframe流程图内步骤
            if(!positioning){
                eventBus.publish("selectFlowMapStep.update");
            }
        }
    }
}

//返回实际审批类型按钮实际对应的名称
function getApproveBtnName({
    approveType,
    btnText,
    tplData
}){
    if(!tplData.flowOperationNameMap){
        return btnText;
    }
    var text = btnText;
    tplData.flowOperationNameMap.find(function(item){
        if(item.eventName === approveType){
            text = item.operationName;
            return true;
        }
    });
    return text;
}

function renderName (name) {
    var userName = '';
    if(name){
        if(/^[\u4e00-\u9fa5]/.test(name)){
            if(name.length > 3){
                userName = name.substr(0,2);
            }else if(name.length == 3){
                userName = name.substr(1);
            }else{
                userName = name.substr(0,2);
            }
        }else{
            userName = name.substr(0,2);
        }
    }
    return userName;
}

export {
    initStepData,
    initAllStepData,//清洗步骤数据，上面那个比较老，以这个为准
    validateSteps,//校验步骤node信息
    getApproveBtnName,//返回实际审批类型按钮实际对应的名称
    renderName,
}